Hibernate Associations (Relationships)

Hibernate, একটি জনপ্রিয় ORM (Object-Relational Mapping) ফ্রেমওয়ার্ক, object-relational mapping এর মাধ্যমে Java অবজেক্ট এবং ডেটাবেস টেবিলের মধ্যে সম্পর্ক (associations) তৈরি করে। Hibernate সম্পর্কের (relationship) জন্য বিভিন্ন ধরনের অ্যানোটেশন ব্যবহার করে, যা আপনাকে বিভিন্ন ধরণের রিলেশন (এটা হতে পারে one-to-many, many-to-many, one-to-one, ইত্যাদি) মডেল করতে সাহায্য করে।

Hibernate-এ চারটি প্রধান সম্পর্কের ধরন রয়েছে:

1. One-to-One Relationship
2. One-to-Many Relationship
3. Many-to-One Relationship
4. Many-to-Many Relationship

প্রতিটি সম্পর্কের জন্য Hibernate-এ সংশ্লিষ্ট অ্যানোটেশন এবং কনফিগারেশন রয়েছে।

1. One-to-One Relationship

এটি এমন একটি সম্পর্ক যেখানে একটি অবজেক্টের সাথে শুধুমাত্র একটি সম্পর্কিত অবজেক্ট থাকে। উদাহরণস্বরূপ, একটি Person অবজেক্টের সাথে একটি Passport অবজেক্ট থাকতে পারে, যেখানে একটি Person শুধুমাত্র একটি Passport ধারণ করতে পারে।

One-to-One Relationship এর উদাহরণ:

import javax.persistence.Entity;
import javax.persistence.Id;
import javax.persistence.OneToOne;

@Entity
public class Person {

    @Id
    private int id;
    private String name;

    @OneToOne(mappedBy = "person") // 'person' refers to the field in Passport class
    private Passport passport;

    // Getters and Setters
}

@Entity
public class Passport {

    @Id
    private int passportId;
    private String country;

    @OneToOne
    private Person person;

    // Getters and Setters
}

এখানে, Person ক্লাসের মধ্যে Passport অবজেক্ট একটি One-to-One সম্পর্ক তৈরি করেছে, এবং mappedBy ব্যবহার করে এই সম্পর্কের মালিকানা Passport ক্লাসে নির্দেশিত হয়েছে।

2. One-to-Many Relationship

এই সম্পর্কটি তখন ব্যবহৃত হয় যখন একটিমাত্র অবজেক্ট অনেক অবজেক্টের সাথে সম্পর্কিত থাকে। উদাহরণস্বরূপ, একটি Department অবজেক্টের সাথে অনেকগুলো Employee অবজেক্ট থাকতে পারে, কিন্তু প্রতিটি Employee শুধুমাত্র একটি Department এর সাথে সম্পর্কিত।

One-to-Many Relationship এর উদাহরণ:

import javax.persistence.Entity;
import javax.persistence.Id;
import javax.persistence.OneToMany;

@Entity
public class Department {

    @Id
    private int deptId;
    private String deptName;

    @OneToMany(mappedBy = "department") // 'department' refers to the field in Employee class
    private List<Employee> employees;

    // Getters and Setters
}

@Entity
public class Employee {

    @Id
    private int empId;
    private String empName;

    @ManyToOne
    private Department department;

    // Getters and Setters
}

এখানে, Department ক্লাসের মধ্যে Employee এর একটি One-to-Many সম্পর্ক তৈরি করা হয়েছে। mappedBy দ্বারা সম্পর্কের মালিকানা Employee ক্লাসে নির্ধারণ করা হয়েছে।

3. Many-to-One Relationship

এই সম্পর্কটি তখন ব্যবহৃত হয় যখন একাধিক অবজেক্ট একটি সাধারণ অবজেক্টের সাথে সম্পর্কিত থাকে। উদাহরণস্বরূপ, অনেক Employee এর সাথে একটি Department থাকতে পারে, যেখানে প্রতিটি Employee শুধুমাত্র একটি Department এর সাথে সম্পর্কিত।

Many-to-One Relationship এর উদাহরণ:

import javax.persistence.Entity;
import javax.persistence.Id;
import javax.persistence.ManyToOne;

@Entity
public class Employee {

    @Id
    private int empId;
    private String empName;

    @ManyToOne
    private Department department; // Many Employees belong to one Department

    // Getters and Setters
}

এখানে, Employee ক্লাসের মধ্যে Department এর সাথে একটি Many-to-One সম্পর্ক তৈরি করা হয়েছে। এতে অনেক Employee একটি Department এর সাথে সম্পর্কিত।

4. Many-to-Many Relationship

এই সম্পর্কটি তখন ব্যবহৃত হয় যখন একাধিক অবজেক্ট একাধিক অবজেক্টের সাথে সম্পর্কিত থাকে। উদাহরণস্বরূপ, একটি Student এর সাথে অনেক Course থাকতে পারে এবং একটি Course এর সাথে অনেক Student থাকতে পারে।

Many-to-Many Relationship এর উদাহরণ:

import javax.persistence.Entity;
import javax.persistence.Id;
import javax.persistence.ManyToMany;
import java.util.List;

@Entity
public class Student {

    @Id
    private int studentId;
    private String studentName;

    @ManyToMany(mappedBy = "students") // 'students' refers to the field in Course class
    private List<Course> courses;

    // Getters and Setters
}

@Entity
public class Course {

    @Id
    private int courseId;
    private String courseName;

    @ManyToMany
    private List<Student> students;

    // Getters and Setters
}

এখানে, Student এবং Course ক্লাসগুলির মধ্যে একটি Many-to-Many সম্পর্ক তৈরি করা হয়েছে। mappedBy ব্যবহার করে Course ক্লাসের মধ্যে সম্পর্কের মালিকানা নির্ধারণ করা হয়েছে।

Hibernate Associations (Relationships) Summary

Hibernate Associations বা Relationships আপনাকে ডেটাবেসের টেবিলগুলির মধ্যে সম্পর্ক স্থাপন করতে সহায়তা করে এবং এগুলি সহজে মডেল করা যায়। Hibernate এর @OneToOne, @OneToMany, @ManyToOne, এবং @ManyToMany অ্যানোটেশনগুলির মাধ্যমে আপনি অবজেক্ট-রিলেশনাল ম্যাপিং (ORM) সহজে করতে পারেন। এগুলি ব্যবহার করে আপনি বাস্তব জগতের সম্পর্কগুলি অবজেক্ট মডেলে সঠিকভাবে মডেল করতে পারবেন, যা ডেটাবেসের ডাটা ম্যানিপুলেশন এবং কোডের মেন্টেনেবিলিটি আরও সহজ করে তোলে।

Hibernate এর One-to-One Association হল একটি সম্পর্ক যেখানে দুটি entity একে অপরের সাথে একে একে সম্পর্কিত থাকে। অর্থাৎ, একটি entity একটি ইনস্ট্যান্সের সাথে অন্য একটি entity-এর একক ইনস্ট্যান্সের সাথে সম্পর্ক স্থাপন করে।

একটি সাধারণ উদাহরণ হতে পারে Person এবং Passport এর মধ্যে সম্পর্ক, যেখানে প্রতিটি Person একটি মাত্র Passport ধারণ করে এবং প্রতিটি Passport শুধুমাত্র একটি Person এর সাথে সম্পর্কিত থাকে।

Hibernate-এ One-to-One Association তৈরি করতে @OneToOne এনোটেশন ব্যবহার করা হয়। এর সাথে @JoinColumn বা mappedBy এনোটেশন ব্যবহার করে সম্পর্কটি নির্দিষ্ট করা হয়।

One-to-One Association এর ধরন

Hibernate-এ One-to-One Association এর দুটি প্রধান ধরন রয়েছে:

1. Unidirectional One-to-One Association: একদিকে একে অপরের সাথে সম্পর্কিত থাকে, অর্থাৎ একটি entity অন্য entity এর প্রতি সম্পর্ক রাখে, কিন্তু অন্য entity এর কাছ থেকে সম্পর্কটি নির্ধারিত নয়।
2. Bidirectional One-to-One Association: দুইটি entity একে অপরের সাথে সম্পর্কিত থাকে। এটি দুটি entity থেকে একে অপরকে রেফারেন্স করে, অর্থাৎ একটি entity অন্য entity এর সাথে সম্পর্ক রাখে এবং অন্য entity টিও প্রথম entity এর সাথে সম্পর্ক রাখে।

One-to-One Association Implementation

এখানে, আমরা একটি Person এবং Passport ক্লাসের মধ্যে One-to-One সম্পর্ক তৈরি করব।

Step 1: Entity Classes তৈরি করা

Person.java (Entity Class)

import javax.persistence.*;

@Entity
@Table(name = "person")
public class Person {

    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    @Column(name = "id")
    private int id;

    @Column(name = "name")
    private String name;

    @OneToOne(mappedBy = "person", cascade = CascadeType.ALL)  // One-to-One relationship
    private Passport passport;

    // Constructors, Getters, Setters
    public Person() {}

    public Person(String name) {
        this.name = name;
    }

    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public Passport getPassport() {
        return passport;
    }

    public void setPassport(Passport passport) {
        this.passport = passport;
    }
}

Passport.java (Entity Class)

import javax.persistence.*;

@Entity
@Table(name = "passport")
public class Passport {

    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    @Column(name = "id")
    private int id;

    @Column(name = "passport_number")
    private String passportNumber;

    @OneToOne
    @JoinColumn(name = "person_id")  // Foreign key to the "person" table
    private Person person;

    // Constructors, Getters, Setters
    public Passport() {}

    public Passport(String passportNumber) {
        this.passportNumber = passportNumber;
    }

    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }

    public String getPassportNumber() {
        return passportNumber;
    }

    public void setPassportNumber(String passportNumber) {
        this.passportNumber = passportNumber;
    }

    public Person getPerson() {
        return person;
    }

    public void setPerson(Person person) {
        this.person = person;
    }
}

এখানে:

• @OneToOne(mappedBy = "person"): Person ক্লাসের passport ফিল্ডের মাধ্যমে Passport ক্লাসের সাথে one-to-one সম্পর্ক স্থাপন করা হয়েছে। mappedBy অ্যাট্রিবিউট দ্বারা Hibernate কে বলে দেয়া হচ্ছে যে, Passport ক্লাসের person ফিল্ডটি এই সম্পর্কের মালিক।
• @JoinColumn(name = "person_id"): Passport ক্লাসে person_id নামে একটি কলাম তৈরি হবে, যা Person টেবিলের প্রাইমারি কী এর সাথে সম্পর্কিত থাকবে।

Step 2: Hibernate Configuration File (hibernate.cfg.xml)

Hibernate কনফিগারেশন ফাইলটি তৈরি করতে হয় যা Hibernate সেশন ফ্যাক্টরি সেটআপ করবে এবং ডেটাবেস সংযোগের জন্য কনফিগারেশন সরবরাহ করবে।

<!DOCTYPE hibernate-configuration PUBLIC "-//Hibernate/Hibernate Configuration DTD 3.0//EN" "http://hibernate.sourceforge.net/hibernate-configuration-3.0.dtd">
<hibernate-configuration>
    <session-factory>
        <!-- JDBC Database connection settings -->
        <property name="hibernate.connection.driver_class">org.h2.Driver</property>
        <property name="hibernate.connection.url">jdbc:h2:mem:testdb</property>
        <property name="hibernate.connection.username">sa</property>
        <property name="hibernate.connection.password"></property>

        <!-- JDBC connection pool settings -->
        <property name="hibernate.c3p0.min_size">5</property>
        <property name="hibernate.c3p0.max_size">20</property>

        <!-- Specify dialect -->
        <property name="hibernate.dialect">org.hibernate.dialect.H2Dialect</property>

        <!-- Enable Hibernate's automatic session context management -->
        <property name="hibernate.current_session_context_class">thread</property>

        <!-- Echo all executed SQL to stdout -->
        <property name="hibernate.show_sql">true</property>

        <!-- Drop and re-create the database schema on startup -->
        <property name="hibernate.hbm2ddl.auto">update</property>

        <!-- Disable the second-level cache -->
        <property name="hibernate.cache.provider_class">org.hibernate.cache.internal.NoCacheProvider</property>
    </session-factory>
</hibernate-configuration>

Step 3: Hibernate SessionFactory তৈরি এবং CRUD অপারেশন

Hibernate সেশন তৈরি করে এবং Person এবং Passport এর মধ্যে One-to-One সম্পর্ক তৈরি করতে নিচের কোড ব্যবহার করা যেতে পারে।

import org.hibernate.*;
import org.hibernate.cfg.Configuration;

public class OneToOneExample {
    public static void main(String[] args) {

        // SessionFactory তৈরি করা
        SessionFactory factory = new Configuration().configure("hibernate.cfg.xml")
                .addAnnotatedClass(Person.class)
                .addAnnotatedClass(Passport.class)
                .buildSessionFactory();

        Session session = factory.getCurrentSession();

        try {
            // একটি নতুন Person অবজেক্ট তৈরি করা
            Person person = new Person("John Doe");

            // একটি নতুন Passport অবজেক্ট তৈরি করা
            Passport passport = new Passport("P123456789");

            // Person এবং Passport কে একে অপরের সাথে সম্পর্কিত করা
            person.setPassport(passport);
            passport.setPerson(person);

            // ট্রানজেকশন শুরু করা
            session.beginTransaction();

            // Person এবং Passport কে সেভ করা
            session.save(person);

            // ট্রানজেকশন কমিট করা
            session.getTransaction().commit();

            // Person এর Passport রিট্রিভ করা
            session = factory.getCurrentSession();
            session.beginTransaction();

            Person retrievedPerson = session.get(Person.class, person.getId());
            System.out.println("Retrieved Person: " + retrievedPerson.getName());
            System.out.println("Passport Number: " + retrievedPerson.getPassport().getPassportNumber());

            // ট্রানজেকশন কমিট করা
            session.getTransaction().commit();
        } finally {
            factory.close();
        }
    }
}

এখানে:

• Person এবং Passport একে অপরের সাথে One-to-One সম্পর্কিত।
• session.save(person) ব্যবহার করে Person এবং Passport অবজেক্ট সেভ করা হচ্ছে।
• পরে session.get(Person.class, person.getId()) ব্যবহার করে Person এবং সম্পর্কিত Passport অবজেক্ট রিট্রিভ করা হচ্ছে।

One-to-One Association এর সুবিধা

Hibernate-এ One-to-One Association অবজেক্ট-রিলেশনাল ম্যাপিং করার একটি গুরুত্বপূর্ণ উপায়। এটি Java objects এবং রিলেশনাল ডেটাবেস টেবিলের মধ্যে সম্পর্ক স্থাপন করতে সাহায্য করে। Hibernate এর সাহায্যে আপনি একে অপরের সাথে সম্পর্কিত দুটি entity এর মধ্যে ডেটাবেস সম্পর্ক সহজে তৈরি এবং পরিচালনা করতে পারবেন। @OneToOne, @JoinColumn, এবং mappedBy এনোটেশন ব্যবহার করে এটি কার্যকরভাবে বাস্তবায়ন করা হয়।

One-to-Many এবং Many-to-One হল Hibernate এর মধ্যে সাধারণভাবে ব্যবহৃত association types যা দুটি entity এর মধ্যে সম্পর্ক বা relationship নির্ধারণ করে। এগুলি object-relational mapping (ORM) সম্পর্কিত ধারণা, যা আপনাকে ডেটাবেস টেবিলের মধ্যে সম্পর্ক তৈরি করার জন্য সাহায্য করে।

এখানে, আমরা One-to-Many এবং Many-to-One সম্পর্কের মধ্যে পার্থক্য এবং কীভাবে এই সম্পর্কগুলো Hibernate-এ তৈরি করা হয়, তা বিস্তারিতভাবে আলোচনা করব।

1. One-to-Many Association

One-to-Many সম্পর্ক তখন হয় যখন একটি entity অন্য একাধিক entity এর সাথে সম্পর্কিত থাকে। এর মানে হলো যে, এক entity এর একাধিক ইনস্ট্যান্স অন্য একটি entity এর সাথে সম্পর্কিত হতে পারে।

One-to-Many সম্পর্কের উদাহরণ:

ধরা যাক, একজন Author একাধিক Book এর সাথে সম্পর্কিত। এখানে, একজন Author এর অনেক Book থাকতে পারে, কিন্তু একটি Book এর শুধুমাত্র একটি Author থাকবে।

Hibernate Mapping Example (One-to-Many)

Author.java (One-to-Many):

import javax.persistence.Entity;
import javax.persistence.Id;
import javax.persistence.OneToMany;
import java.util.Set;

@Entity
public class Author {

    @Id
    private int id;
    private String name;

    @OneToMany(mappedBy = "author")
    private Set<Book> books;

    // Constructor, getters, and setters
    public Author() {}

    public Author(int id, String name) {
        this.id = id;
        this.name = name;
    }

    public Set<Book> getBooks() {
        return books;
    }

    public void setBooks(Set<Book> books) {
        this.books = books;
    }

    // Other getters and setters
}

Book.java (Many-to-One):

import javax.persistence.Entity;
import javax.persistence.Id;
import javax.persistence.ManyToOne;

@Entity
public class Book {

    @Id
    private int id;
    private String title;

    @ManyToOne
    private Author author;

    // Constructor, getters, and setters
    public Book() {}

    public Book(int id, String title, Author author) {
        this.id = id;
        this.title = title;
        this.author = author;
    }

    public Author getAuthor() {
        return author;
    }

    public void setAuthor(Author author) {
        this.author = author;
    }

    // Other getters and setters
}

ব্যাখ্যা:

• Author Entity-এ @OneToMany(mappedBy = "author") অ্যানোটেশন ব্যবহার করা হয়েছে। এটি নির্দেশ করে যে Author Entity এর সাথে সম্পর্কিত Book এর ইনস্ট্যান্স গুলো একাধিক হতে পারে। mappedBy এর মাধ্যমে author ফিল্ডটি Book Entity এর মধ্যে সম্পর্ককে নির্দেশ করে।
• Book Entity-এ @ManyToOne অ্যানোটেশন ব্যবহার করা হয়েছে, যা নির্দেশ করে যে একটি Book এর শুধুমাত্র একটি Author থাকবে।

2. Many-to-One Association

Many-to-One সম্পর্ক তখন হয় যখন একাধিক entity অন্য একটি entity এর সাথে সম্পর্কিত থাকে। এটি সাধারণত One-to-Many সম্পর্কের বিপরীত, যেখানে একাধিক child entity একটি parent entity এর সাথে সম্পর্কিত হয়।

Hibernate Mapping Example (Many-to-One)

Book.java (Many-to-One):

import javax.persistence.Entity;
import javax.persistence.Id;
import javax.persistence.ManyToOne;

@Entity
public class Book {

    @Id
    private int id;
    private String title;

    @ManyToOne
    private Author author;

    // Constructor, getters, and setters
    public Book() {}

    public Book(int id, String title, Author author) {
        this.id = id;
        this.title = title;
        this.author = author;
    }

    public Author getAuthor() {
        return author;
    }

    public void setAuthor(Author author) {
        this.author = author;
    }

    // Other getters and setters
}

Author.java (One-to-Many):

import javax.persistence.Entity;
import javax.persistence.Id;
import javax.persistence.OneToMany;
import java.util.Set;

@Entity
public class Author {

    @Id
    private int id;
    private String name;

    @OneToMany(mappedBy = "author")
    private Set<Book> books;

    // Constructor, getters, and setters
    public Author() {}

    public Author(int id, String name) {
        this.id = id;
        this.name = name;
    }

    public Set<Book> getBooks() {
        return books;
    }

    public void setBooks(Set<Book> books) {
        this.books = books;
    }

    // Other getters and setters
}

ব্যাখ্যা:

• Book Entity-এ @ManyToOne অ্যানোটেশন ব্যবহার করা হয়েছে, যা Book এর একটি instance এর সাথে Author এর সম্পর্ক স্থাপন করে। এটি নির্দেশ করে যে অনেকগুলো Book একটি Author এর সাথে সম্পর্কিত হতে পারে।
• Author Entity-এ @OneToMany অ্যানোটেশন ব্যবহার করা হয়েছে, যা Author এর সাথে সম্পর্কিত একাধিক Book কে ম্যাপ করে।

3. Cascade Operations

Hibernate cascade operations সাপোর্ট করে, যার মাধ্যমে আপনি একটি entity এর পরিবর্তনগুলো অন্য সম্পর্কিত entities-এ (যেমন Books এর ক্ষেত্রে Author) cascade করতে পারেন। উদাহরণস্বরূপ, যদি একটি Author ডিলিট করা হয়, তবে সম্পর্কিত সব Book গুলিও ডিলিট করা হতে পারে। Cascade অপারেশন One-to-Many এবং Many-to-One উভয় সম্পর্কেই কার্যকরী।

Cascade Example:

@OneToMany(mappedBy = "author", cascade = CascadeType.ALL)
private Set<Book> books;

এখানে cascade = CascadeType.ALL দিয়ে সব ধরনের cascade অপারেশন (যেমন, persist, merge, remove) Book গুলির উপর প্রযোজ্য হবে যখন Author এর অবস্থা পরিবর্তিত হবে।

4. Fetch Types: Lazy vs Eager

Hibernate সম্পর্কের লোডিংকে নিয়ন্ত্রণ করার জন্য fetch type সাপোর্ট করে। এর মধ্যে দুটি মূল ধরন রয়েছে:

• Lazy Fetching: সম্পর্কিত entities কেবল তখনই লোড হবে যখন প্রয়োজন হবে। এটি default fetch type।
• Eager Fetching: সম্পর্কিত entities অটোমেটিক্যালি লোড হবে যখন মূল entity লোড হবে।

Lazy Loading Example:

@OneToMany(mappedBy = "author", fetch = FetchType.LAZY)
private Set<Book> books;

এখানে Lazy loading এর মাধ্যমে books collection কেবল তখনই লোড হবে যখন এটি প্রোগ্রামmatically অ্যাক্সেস করা হবে।

5. Database Schema and Foreign Key Constraints

Hibernate One-to-Many এবং Many-to-One সম্পর্কের মাধ্যমে ডেটাবেসে foreign key constraints তৈরি করে।

• One-to-Many: এখানে Many entity (Book) টেবিলের মধ্যে foreign key হিসাবে One entity (Author) এর আইডি রাখা হবে।
• Many-to-One: একাধিক Book একই Author এর সাথে সম্পর্কিত থাকে, তাই Book টেবিলের মধ্যে Author এর প্রাইমারি কী foreign key হিসাবে ব্যবহৃত হবে।

• One-to-Many সম্পর্ক Author এর মতো একাধিক ইনস্ট্যান্সের সাথে সম্পর্কিত হতে পারে, যেমন Book।
• Many-to-One সম্পর্ক অনেক গুলি Book এর মধ্যে একটি Author সম্পর্কিত থাকে।
• Hibernate এ এই সম্পর্কগুলো @OneToMany এবং @ManyToOne অ্যানোটেশন দিয়ে কনফিগার করা হয়, এবং cascade, fetch type, foreign key constraints এর মাধ্যমে সম্পর্কিত ডেটাবেস টেবিলের মধ্যে সম্পর্ক তৈরি হয়।

Many-to-Many (M:N) সম্পর্ক হল এমন একটি সম্পর্ক যেখানে একটি এন্টিটি (Entity) একাধিক অন্য এন্টিটির সাথে সম্পর্কিত থাকে, এবং অপর এন্টিটি একইভাবে প্রথম এন্টিটির একাধিক ইনস্ট্যান্সের সাথে সম্পর্কিত থাকে। Hibernate-এ Many-to-Many সম্পর্ক ম্যাপিং করার জন্য, সাধারণত একটি join table ব্যবহৃত হয় যা দুটি টেবিলের মধ্যে সম্পর্ক স্থাপন করে।

Hibernate Many-to-Many সম্পর্ক বাস্তবায়ন করতে @ManyToMany অ্যানোটেশন ব্যবহার করা হয়। এছাড়া @JoinTable অ্যানোটেশন ব্যবহার করা হয়, যা join table এর কনফিগারেশন সম্পাদন করে।

Many-to-Many সম্পর্কের উদাহরণ

ধরা যাক, আমাদের একটি Student এবং একটি Course Entity Class আছে। এক ছাত্র (Student) একাধিক কোর্সে (Course) ভর্তি হতে পারে এবং এক কোর্সে একাধিক ছাত্র (Student) থাকতে পারে। এটি একটি Many-to-Many সম্পর্ক।

ধাপ 1: Entity ক্লাস তৈরি করা

Student Entity Class:

import javax.persistence.*;
import java.util.HashSet;
import java.util.Set;

@Entity
@Table(name = "student")
public class Student {

    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private int id;

    private String name;

    @ManyToMany
    @JoinTable(
        name = "student_course", 
        joinColumns = @JoinColumn(name = "student_id"), 
        inverseJoinColumns = @JoinColumn(name = "course_id")
    )
    private Set<Course> courses = new HashSet<>();

    public Student() {}

    public Student(String name) {
        this.name = name;
    }

    // Getters and Setters
    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public Set<Course> getCourses() {
        return courses;
    }

    public void setCourses(Set<Course> courses) {
        this.courses = courses;
    }

    // Add helper method to add course
    public void addCourse(Course course) {
        courses.add(course);
        course.getStudents().add(this);
    }
}

Course Entity Class:

import javax.persistence.*;
import java.util.HashSet;
import java.util.Set;

@Entity
@Table(name = "course")
public class Course {

    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private int id;

    private String title;

    @ManyToMany(mappedBy = "courses")
    private Set<Student> students = new HashSet<>();

    public Course() {}

    public Course(String title) {
        this.title = title;
    }

    // Getters and Setters
    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }

    public String getTitle() {
        return title;
    }

    public void setTitle(String title) {
        this.title = title;
    }

    public Set<Student> getStudents() {
        return students;
    }

    public void setStudents(Set<Student> students) {
        this.students = students;
    }
}

ধাপ 2: Hibernate Configuration ফাইল তৈরি করা

Hibernate কনফিগারেশন ফাইল (hibernate.cfg.xml) তৈরি করুন, যা ডেটাবেস সংযোগ এবং অন্যান্য সেটিংস কনফিগার করবে।

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE hibernate-configuration PUBLIC "-//Hibernate/Hibernate Configuration DTD 3.0//EN" "http://hibernate.sourceforge.net/hibernate-configuration-3.0.dtd">
<hibernate-configuration>

    <session-factory>
        <property name="hibernate.connection.driver_class">com.mysql.cj.jdbc.Driver</property>
        <property name="hibernate.connection.url">jdbc:mysql://localhost:3306/mydatabase</property>
        <property name="hibernate.connection.username">root</property>
        <property name="hibernate.connection.password">password</property>

        <property name="hibernate.dialect">org.hibernate.dialect.MySQL5Dialect</property>
        <property name="hibernate.show_sql">true</property>
        <property name="hibernate.hbm2ddl.auto">update</property>

        <mapping class="com.example.model.Student"/>
        <mapping class="com.example.model.Course"/>
    </session-factory>

</hibernate-configuration>

ধাপ 3: Many-to-Many সম্পর্কের সাথে ডেটাবেসে ডেটা সন্নিবেশ করা (Insert Data)

এখন, Hibernate ব্যবহার করে আমরা Student এবং Course ডেটা সন্নিবেশ করতে পারি এবং Many-to-Many সম্পর্ক স্থাপন করতে পারি।

import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.hibernate.cfg.Configuration;

public class HibernateApp {
    public static void main(String[] args) {
        // Create SessionFactory
        SessionFactory factory = new Configuration().configure("hibernate.cfg.xml").addAnnotatedClass(Student.class).addAnnotatedClass(Course.class).buildSessionFactory();

        // Create session
        Session session = factory.getCurrentSession();

        try {
            // Create new Student object
            Student student1 = new Student("John");
            Student student2 = new Student("Alice");

            // Create new Course objects
            Course course1 = new Course("Math");
            Course course2 = new Course("Science");

            // Establish the relationship (add courses to students and students to courses)
            student1.addCourse(course1);
            student1.addCourse(course2);

            student2.addCourse(course1);

            // Start a transaction
            session.beginTransaction();

            // Save the students and courses
            session.save(student1);
            session.save(student2);
            session.save(course1);
            session.save(course2);

            // Commit transaction
            session.getTransaction().commit();

            System.out.println("Saved students and courses successfully!");
        } finally {
            factory.close();
        }
    }
}

Explanation:

• @ManyToMany: এটি Student এবং Course ক্লাসের মধ্যে Many-to-Many সম্পর্ক প্রতিষ্ঠা করে।
  • @JoinTable: এটি একটি join table তৈরি করতে সাহায্য করে যা student_course নামে হবে এবং এটি দুটি টেবিলের মধ্যে সম্পর্ক স্থাপন করবে।
  • joinColumns: এটি student_id কে student টেবিলের id ফিল্ডে ম্যাপ করবে।
  • inverseJoinColumns: এটি course_id কে course টেবিলের id ফিল্ডে ম্যাপ করবে।
• mappedBy: এটি Course ক্লাসের মধ্যে Student ক্লাসের Many-to-Many সম্পর্কের inverse side নির্দেশ করে, যার মানে হল যে Course টেবিলের মধ্যে ডেটা সম্পর্কিত থাকলেও, Student ক্লাসের courses প্রপার্টি সংযুক্ত থাকে।

ধাপ 4: Many-to-Many সম্পর্ক থেকে ডেটা রিট্রিভ করা (Retrieve Data)

এখন, ডেটা রিট্রিভ করতে HQL (Hibernate Query Language) ব্যবহার করা যেতে পারে। নিচে একটি উদাহরণ দেওয়া হলো:

import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.hibernate.cfg.Configuration;
import org.hibernate.query.Query;

import java.util.List;

public class HibernateApp {
    public static void main(String[] args) {
        SessionFactory factory = new Configuration().configure("hibernate.cfg.xml").addAnnotatedClass(Student.class).addAnnotatedClass(Course.class).buildSessionFactory();
        Session session = factory.getCurrentSession();

        try {
            session.beginTransaction();

            // Create an HQL query to get all students and their courses
            Query<Student> query = session.createQuery("from Student s join fetch s.courses", Student.class);
            List<Student> students = query.getResultList();

            // Display the students and their courses
            for (Student student : students) {
                System.out.println("Student: " + student.getName());
                for (Course course : student.getCourses()) {
                    System.out.println("  - " + course.getTitle());
                }
            }

            session.getTransaction().commit();
        } finally {
            factory.close();
        }
    }
}

Explanation:

• HQL query: from Student s join fetch s.courses এই কোয়েরি Student এবং তার courses সম্পর্কিত ডেটা সংগ্রহ করবে।
• join fetch: এটি fetch join ব্যবহার করে courses এর ডেটা student এর সাথে একত্রে আনে।

• Hibernate এ Many-to-Many relationship তৈরি করার জন্য @ManyToMany অ্যানোটেশন এবং @JoinTable ব্যবহার করা হয়, যা টেবিলগুলির মধ্যে সম্পর্ক তৈরি এবং পরিচালনা করে।
• Hibernate Entity Class, join table এবং HQL ব্যবহার করে আপনি Many-to-Many সম্পর্ক তৈরি করতে, ডেটা সন্নিবেশ করতে এবং রিট্রিভ করতে পারেন।
• Hibernate object-relational mapping (ORM) এর মাধ্যমে সম্পর্কিত ডেটাবেসের সঙ্গে সহজভাবে কাজ করতে সাহায্য করে।